package sanrenxing.Class.dao.impl;

import sanrenxing.Class.dao.ClasssDao;
import sanrenxing.Class.domain.ClassName;
import sanrenxing.Class.domain.Classs;
import sanrenxing.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
 * @author Administrator
 * @date 2020/9/27 11:31
 * 编辑者：谭飞
 * 功能：
 */
public class ClasssDaoImpl implements ClasssDao {
    /**
     * 将班级实体对象添加到数据库class表中
     *
     * @param classs 班级对象
     * @return 成功添加的行数(1 : 添加成功 ; 0 : 添加失败)
     */
    @Override
    public int add(Classs classs) {
        //声明数据库连接对象
        Connection conn = null;
        //声明预编译语句对象
        PreparedStatement pstmt = null;
        //定义影响行数的变量
        int rows = 0;
        try {
            //实例化数据库连接对象
            conn = JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql = "insert into class(classId,className,instructorId,teacherId,studentCount) values(?,?,?,?,?)";
            //实例化预编译语句对象
            pstmt = conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
//            pstmt.setInt(1, classs.getClassId());
            pstmt.setInt(1,classs.getClassId());
            pstmt.setString(2, classs.getClassName());
            pstmt.setInt(3, classs.getInstructorId());
            pstmt.setInt(4, classs.getTeacherId());
            pstmt.setInt(5, classs.getStudentCount());

            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows = pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null, pstmt, conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     * 根据班级编号主键从数据库class表中删除指定班级数据
     *
     * @param classId 班级编号主键
     * @return 删除影响的行数(1 : 删除成功 ; 0 : 删除失败)
     */
    @Override
    public int delete(int classId) {
        //声明数据库连接对象
        Connection conn = null;
        //声明预编译语句对象
        PreparedStatement pstmt = null;
        //定义影响行数的变量
        int rows = 0;
        try {
            //实例化数据库连接对象
            conn = JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql = "delete from class where classId=?";
            //实例化预编译语句对象
            pstmt = conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1, classId);
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows = pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null, pstmt, conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     * 将班级对象数据修改到数据库class表中
     *
     * @param classs 班级对象
     * @return 修改影响的行数(1 : 修改成功 ; 0 : 修改失败)
     */
    @Override
    public int update(Classs classs) {
        //声明数据库连接对象
        Connection conn = null;
        //声明预编译语句对象
        PreparedStatement pstmt = null;
        //定义影响行数的变量
        int rows = 0;
        try {
            //实例化数据库连接对象
            conn = JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql = "update class set className=?,instructorId=?," +
                    "teacherId=?,StudentCount=? where classId=?";
            //实例化预编译语句对象
            pstmt = conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setString(1, classs.getClassName());
            pstmt.setInt(2, classs.getInstructorId());
            pstmt.setInt(3, classs.getTeacherId());
            pstmt.setInt(4, classs.getStudentCount());
            pstmt.setInt(5, classs.getClassId());

            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows = pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null, pstmt, conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     * 根据班级编号主键从数据库class表中查找单个班级
     *
     * @param className 班级编号主键
     * @return 班级对象(如果返回null值 ， 表示查找失败)
     */
    @Override
    public Classs findById(String className) {
        //声明数据库连接对象
        Connection conn = null;
        //声明预编译语句对象
        PreparedStatement pstmt = null;
        //声明结果集对象
        ResultSet rs = null;
        //定义返回的教师对象
        Classs classs = null;
        try {
            //实例化数据库连接对象
            conn = JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql = "select * from class where className=?";
            //实例化预编译语句对象
            pstmt = conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setString(1,className);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs = pstmt.executeQuery();
            //判断结果集，并把结果集的数据封装到教师对象中
            if (rs.next()) {
                //实例化教师对象
                classs = new Classs();
                //把结果集数据赋值给教师对象各属性
                classs.setClassId(rs.getInt("classId"));
                classs.setClassName(rs.getString("className"));
                classs.setInstructorId(rs.getInt("instructorId"));
                classs.setTeacherId(rs.getInt("teacherId"));
                classs.setStudentCount(rs.getInt("studentCount"));

            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs, pstmt, conn);
        }
        //返回教师对象
        return classs;
    }

    /**
     * 查询数据库class表中所有班级
     *
     * @return 班级对象集合
     */
    @Override
    public List<Classs> findAll() {
        //声明数据库连接对象
        Connection conn = null;
        //声明预编译语句对象
        PreparedStatement pstmt = null;
        //声明结果集对象
        ResultSet rs = null;
        //定义返回的教师对象集合
        List<Classs> classsList = new ArrayList<Classs>();
        try {
            //实例化数据库连接对象
            conn = JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql = "select * from class";
            //实例化预编译语句对象
            pstmt = conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs = pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到教师对象中
            while (rs.next()) {
                //定义教师对象
                Classs classs = new Classs();
                //把结果集数据赋值给教师对象各属性
                classs.setClassId(rs.getInt("calssId"));
                classs.setClassName(rs.getString("className"));
                classs.setInstructorId(rs.getInt("instructorId"));
                classs.setTeacherId(rs.getInt("teacherId"));
//                classs.getStudentCount()rs.getIngetStudentCount()"));
                classs.setStudentCount(rs.getInt("studentCount"));
                //把教师对象添加教师集合中
                classsList.add(classs);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs, pstmt, conn);
        }
        //返回教师对象集合
        return classsList;
    }

    /**
     * 从数据库class表中查询指定页的班级对象集合
     *
     * @param rows  每页的班级行数
     * @param pages 页数
     * @return 当前页的班级对象集合
     */
    @Override
    public List<Classs> findByPage(int rows, int pages) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的班级对象集合
        List<Classs> classsList=new ArrayList<Classs>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select * from class limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给分页语句占位符赋值
            //分页语句：select * from 表名 limits (pages-1)*rows,rows
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到班级对象中
            while(rs.next()){
                //定义班级对象
                Classs classs=new Classs();
                //把结果集数据赋值给班级对象各属性
                classs.setClassId(rs.getInt("calssId"));
                classs.setClassName(rs.getString("className"));
                classs.setInstructorId(rs.getInt("instructorId"));
                classs.setTeacherId(rs.getInt("teacherId"));
                classs.setStudentCount(rs.getInt("studentCount"));
                //把班级对象添加班级集合中
                classsList.add(classs);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回班级对象集合
        return classsList;
    }


    /**
     * 统计数据库class表中记录总数
     *
     * @return 班级表中记录总数
     */
    @Override
    public int count() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数据行数
        int rowCount=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select count(*) StudentCount from class";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集，并获得总行数
            if(rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                //    rowCount=rs.getIngetStudentCount()");
                rowCount=rs.getInt("StudentCount");
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回表中数据总行数
        return rowCount;
    }

    /**
     * 条件分页查询
     *
     * @param rows      每页行数
     * @param pages     页数
     * @param condition 条件
     * @return 班级对象集合
     */
    @Override
    public List<Classs> findByPage(int rows, int pages, String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的班级对象集合
        List<Classs> classsList =new ArrayList<Classs>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select * from class where 1=1 "+condition+" limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给分页语句占位符赋值
            //分页语句：select * from 表名 limits (pages-1)*rows,rows
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到班级对象中
            while(rs.next()){
                //定义班级对象
                Classs classs=new Classs();
                //把结果集数据赋值给班级对象各属性
                classs.setClassId(rs.getInt("classId"));
                classs.setClassName(rs.getString("className"));
                classs.setInstructorId(rs.getInt("instructorId"));
                classs.setTeacherId(rs.getInt("teacherId"));
                classs.setStudentCount(rs.getInt("studentCount"));
                //把班级对象添加班级集合中
                classsList.add(classs);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回班级对象集合
        return classsList;
    }

    /**
     * 条件统计
     *
     * @param condition 条件
     * @return 班级数
     */
    @Override
    public int count(String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数据行数
        int rowCount=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select count(*) as StudentCount from class where 1=1 "+condition;
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集，并获得总行数
            if(rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                // rowCount=rs.getIngetStudentCount()");
                rowCount=rs.getInt("StudentCount");
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回表中数据总行数
        return rowCount;
    }

    /**
     * 获取查询条件
     *
     * @param classs 班级对象
     * @return 条件字符串
     */
    @Override
    public String getCondition(Classs classs) {
        //定义查询条件字符串，初值为带空格的字符串(注意后续条件中的空格)
        String condition=" ";
        //如果班级对象为空，则直接返 回空字符串
        if(classs==null){
            return condition;
        }
        //如果班级编号不为0
        if(classs.getClassId()!=0){
            condition += " and ClassId="+classs.getClassId();
        }
        //如果班级名称不为空(字符串匹配模糊查询)
        if(classs.getClassName()!=null && classs.getClassName().trim().length()!=0){
            condition += " and className like '%"+classs.getClassName()+"%' ";
        }
        //如果班主任编号不为空
        if(classs.getInstructorId()!=0 ){
            condition +="and InstructorId="+classs.getInstructorId();
        }
        //如果教师编号不为空
        if(classs.getTeacherId()!=0){
            condition += " and teacherId="+classs.getTeacherId();
        }
        //如果存在班级人数
        if(classs.getStudentCount()!=0){
            condition += " and studentCount="+classs.getStudentCount();
        }
        //返回条件字符串
        return condition;
    }

    /**
     * 查询所有班级名称
     *
     * @return
     */
    @Override
    public List<ClassName> findClassName() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句
        PreparedStatement pstmt=null;
        //声明结果集
        ResultSet rs=null;
        //创建数组
        List<ClassName> classNameList=new ArrayList<>();


        try {
            //实列化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="SELECT  className FROM class";
            //声明预编译语句
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集
            while (rs.next()){
                //把结果集数据赋值给班级名称
                ClassName className=new ClassName();
                className.setClassName (rs.getString("className"));
                //把班级名称添加进集合中
                classNameList.add(className);
            }

        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回结果集
        return classNameList;
    }
}
